Celestin Apprentice 2/Apprentice-Release2.iso/Source Code/C/Games/Xconq 7.0d16/doc/TODO

Text File | 1993-12-20 | 13.6 KB | 364 lines | [TEXT/MPS ]

THINGS TO DO

(These must be handled before releasing the next version.)

--Overall

--GDL

More syntax for generic variants:
  ([str] id default [range]
   (case1 [str] forms ...)  ; can subst ^id with slider value
   (case2 [str] forms ...)
  )

Error messages during reading should indicate current and/or chain
of including modules.

--Types and Objects

Agreement enforce may be absolute (done by game code), by changes in loyalty,
or not at all.
Some unit types should be unwilling to break a treaty.
(In some games,)
Should humans have to declare war explicitly?
DoW may not be possible or meaningful in some games...
DoW is agreement by single player doing the declaration, terms are to
treat side as enemy (doctrine), and to hit other side (how often?),
could demand a surrender of some sort.
DoW must be public.
Up to other sides how to respond.
Peace treaty includes terms to nullify DoW.
In general, terms should be able to include refs to other agreements.
DoW can always be rescinded by player alone, make it have morale
consequences?

Define feelings toward each side as pair of bytes, for/against and
willingness to act on feeling.  Feeling toward own side is morale.

Fix occupancy calcs so that units in exclusive spaces do not have
their sizes counted in overall fullness.

Ensure that borders with edge cells are either always handled
correctly (as in crossing to leave world?) or disabled.

--Setup

Refs to be patched should be handled as Lisp objects in transport slots,
then can cast/eval later to derive actual unit symbolically or with
literal id.

Add usage of range of advantages, indicate in setup dialogs,
complain if exceeded on command line.

--Plans and Tasks

When transport gets as far as it can in transporting a unit, and is
then blocked, should let unit get off if possible, instead of running
to do something else.

If unit's goal is to get to a distance place, but is blockaded by inactive
enemy, consider attacking instead of waiting or trying to go around.

Define a "meet" task where transport and occ (or whatever pair
or group) converge on a mutually acceptable place.  Track progress,
give up if not getting closer.

Check on what happens to dead or immobilized units with tasks.

Check on likely success of resupply task, if dubious commit to forward
motion.  Consult AI or human prefs?

If can never capture anything, don't ever search for easy captures.

Add a generic "orbit" constraint for any plan, tieable to unit and/or
position.  Player can use to set home locations etc.  Useful to be able
to invert and say to avoid some areas.  Test with pbys in flattop staying
with task force while still patrolling around.

When units put to sleep, kernel has to set alarms properly (according
to doctrine or what?).

A hit-unit task should
doublecheck for a nearby
unit of matching type/side that *is* under observation, might be
actual target trying to sneak away.  Don't have to bother if type
cannot move or be carried (should identify all these ahead of time),
disappearance of such a type means that it no longer exists.

Attack tasks should go after undamageable units with visible occupants.

--Actions

In movement-related action, copy z coord properly everywhere (assume
alt-preserving if not otherwise speced).  In check_move_action, look
at unit->z & 1 == 1, check conn capacity else just look at alt limits
and cell capacity.

Check alt diffs in combat actions (and other unit interactions?)

When unit damaged during turn, should adjust acp down as if it had started the
turn damaged.

Changing type should have a material cost, so peon can buy title.
Extend to material prerequisite cost for all actions? (lots of tables!)

When looking for next actor, skip over units that can't possibly do
anything even if they have some acp. (scan the actionvector?)

Add attacker-adjust, defender-adjust to distinguish units in a
group of combat parameters?

Assault and fire need separate ammo consumption.  Limit is like
uum_ammo_to_use_max(u1, u2, m), can request less (how should interfaces
do this smoothly?)  Derive from notion of partial commitment?

Response to capture attempt might be to hit capturing unit?
Capture after combat is really a side effect where a unit surrenders
(implies attacking unit might end up doing the surrendering!).

Chance to hit when firing decreases depending
on distance and type of target.  Define uu range-for-max-hit-chance,
hit-chance-at-max-range, interpolate linearly.

--Backdrop

Interpret contents of "messages" and "special-effects" slots in scorekeepers.

--Coding

Dispatch on ai type when drawing AI info about cell.
Drawing code should be in special file that includes both
relevant ui.h and ai.h

Write a search_straight_line(x0, y0, x1, y1, fn) that scans
exact line between lines.  Could also do 3d version.

To get out of a game, call exit_game(), which calls back to interface
with close_display() or close_all_displays().

Collect/write stats on each call to run_game - # unit scanned, # acted,
# actions, # plan executions.  Also classify by type and side.

Make routines unit_trusts_unit(), unit_{friendly,neutral,enemy}_to_side()?

For cmdline-based progs, check all players specs, then quit if errors.

For each scorekeeper, add an internal flag that saves applicability
of scorekeeper, also calc for current turn - if changed, then AI
analysis code should re-run.

--Misc

Mention in player doc that advantage rounds down rather than up.

Clean up unit_changes_side some more.

Players should be able to indicate a willingness to declare a draw,
all interfaces should be able to display this bit.
Game exits when all players indicate willingness to draw (check
whenever any interface changes one of these)

Doctrine and unit plans should include rules about when units should
attack automatically.  Should be careful or will lose units to foolish
actions.

Handle some glimpses as special event types, such as spotting occupants
in a unit, instead of trying to draw on display somehow.
Call glimpse_unit(side, unit).

Ensure erasure of images of own units that are actually dead and gone.

Fix AI testing script to kill a game if spins too long, then display
how much progress made.  (Add time collection to skelconq?)

--AI

Fix midrange theater boundary to be more like halfway across world, even
if starting area is very small.

When adjusting theaters, decide ahead of time which should grow and
which shrink, then use spare layer to buffer changes while scanning.

Never draw theater boundaries against edge cells.

Explorers still need to attempt to capture any "useful" units seen nearby.

If bases offer any kind of advantage at all, build lots of them.

If only one builder available, should "timeshare" it properly.

Should choose cheap types to hold onto a country after capturing part of
it (also defend the newly captured units properly).

If no penalty for changing builds, then only ever schedule one at a time
(or two if really cheap? how to decide?)

Use perimeter/remote rings only for worlds that need exploration to
find other sides, else make theaters around each side's home, grow
around units in general (a la country growing).  Define a "short-range
interaction radius" that specs growth around each unit.

Downgrade need for a particular type if a large number has accumulated
around builder(s).

Need to record spotting of human-run units that attempt to sneak
away quickly, concentrate patrolling and exploration there.
(in general, keep an accumulated count of contacts in each theater)

Designer should be able to toggle flags for mplayer,
force reevaluation etc.

If moderate-to-high chance of unit surround, should put units in
lines and other formations that can't be surrounded easily.

A side should act primarily defensively if it satisfies a goal,
but the game is not over and another side could take away.

Guess at likely theater for contacts, carve out of existing theaters,
reassign/replan *all* units.

Should detect when a unit has nonzero acp but can't do anything anyway,
and put it in reserve.  (Look for results of NO_ACP?)

When a unit executes its plan, routines like find_target()
either get a value from AI or search around (implicit "nobrains" AI?).
(AI should have prioritized list of targets composed already and
sorted by theater and goal etc.)

When choosing from needed units, favor types that are closer at hand?

Unit should attempt to capture something if it is a) useful (to accomplish
goal directly or indirectly) or b) useful to enemy and should be denied.

If parts of world view not necessarily up-to-date, need to do pickets
or patrols to guarantee as much coverage as possible. (use view dates)

Event types include combat, spotting another unit (with given type/side/
distance/relationship), spotting terrain type, level crossing of unit
attrs (hp, supply), regular intervals, (turn) timeout, player intervention
("wakeup"), change in another unit (death of leader), entered a hex.
For efficiency, define a g_event_radius that is max dist that a unit will
be notified of the appearance of another unit, otherwise have to check all
units against each other.

Fix machine player to know about non-wrapping worlds.

Redo analysis whenever set of active scorekeepers changes (but should
anticipate scorekeepers that might become active in the future?).

Need a way to estimate units hidden in transports, so can freak out
over approaching transports.

--Interface

Decide general recommended algorithm for autoscrolling when near edge
of display.

Add image of Syria flag.

Display unit id if closeups, toplines, etc, if debugging is on.

Draw single selected unit in a stack larger.

If already fully fueled, refuel commands should come back immediately.

Draw single selected occupant in UR corner next to transport, when at
mags that show both transport and occs.

Define a general way to distinguish transports with occs from empty
transports at 16x16 mag.

End-of-game stats should use own system for double-entry bookkeeping.
(should display discrepancies only if nonzero)

Strip out most of xt version, make it quit with a warning usually.

Support player messaging via send_message(side, str, side or sidemask).

Fix interface so that only one base gets ordered to be built, but lots
of infantry from cities.  (in doctrine, feed to interface? - needs to
be part of default doctrine for all sides in a game!)

Add more help nodes to explain general concepts like acp.

Help info should have subr that takes bit vector for types and sends back
a summary of properties or a table row.

Define text generators as
char *make_text(Obj *maker, void *parms, char *buf)
return mallocked string if no buf passed.
Fns are like action_result_desc(side, unit, action, code)...
Need some sort of default grammar used when game designs don't want
to add anything special.
Copy ^0, ... concept for format strings generated by grammars.
Use grammar idea for narrative generation.
Do for actions, notable backdrop events, summaries.
(text disband-narrative
  (self infantry "%2 goes home")
  (u* bomb "%1 dismantles %2")
  )
Match on action args to choose sentence, allow multiple weighted choices
for variety, be able to tailor for each side.
Similar to name gen grammars, but can't share code.
Should be able to do both present and past tense generation.
Routine is describe_thing(side(s), generator, parms[10]).
(Would be generally useful to have a side-to-bit-vector conversion routine...)
"Narrative" different from "message", is past sense, while "message"
describes ongoing things.
Need to do narrative descriptions / events for notable backdrop events
such as migrations, storms, etc.

Replace draw_blast with a generic event callback for transient events,
Allows interface to store or just display directly.
[subsume with historical event recording?]
Define transients in general.  Include duration and manifestation
(name of visual/aural effect(s)), also size and visibility, by
distance and perhaps unit type and/or tech level.
Need a library of splats and sounds.
Supporting interfaces need a timed loop, so kernel sends
"display transient xxx" once and can forget about having
to handle it further (also makes recordable in a sense).
Should be able to tie transients to historical events?
Support multiple sounds - ones for attack, hit, death, use diff ones
for shooting, possibly movement noises.
Should be able to define special win/lose sounds (cheers and raspberries),
attach to interface's handling of events from kernel.

Compute centroid of feature if not defined, and attempting to display it.
Center should be inside.

--Library

Units in std and classic game should *not* have any fuel until complete!

Reduce amts of ship ammo in standard game.

Bases should have long in-lengths in standard and modern games, since
represents automatic support/supply setups, and moderate out-lengths
to support ground units better.

If fighters had a low land/takeoff time, then could attack adj bombers
a lot more than now (realistic), but bombers can't escape then, unless
some sort of generic auto-retreat implemented (a good idea).  Auto-retreat
might happen in addition to the hit, rather than instead of the hit.
Refuel should consume part of flying time, but not all, then can
fly many sorties against nearby targets.

Bases should "anti-protect" aircraft in periods involving both, but
fighters should protect the base.

Finish adding the most common translations to misc/*2game.

Image tool should report which type of resource is generating a
given image, so can find which to hack on (report for selected image only).

Gettysburg brigades should vary in quality and hp.

Set pelops units to be exactly those which participated,
try to model Athenian grain trade (abstractly or concretely?)

WWII strategic games should have large number of predefined agreements
constraining players.  Add more pre-existing units to all sides.
Fleets should take longer to build?